PURE functional. NO side effects. Everything returns, should be deterministic.
Life isn't deterministic. This is why people think it's not useful.
HOW do we deal with LIFE?
Side effects in IO
Pure everywhere else
brilliant
Details
Drawn from, return (opposites)
main ::IO ()
main =do
putStrLn "quit the program? y/n"
ans <- getLine
if ans /="y"thendo
putStrLn "not quitting"
main
else return ()
-- or
when (ans /="y") $do
putStrLn "not quitting"
main
Nil is often used as bottom as well as status. In Haskell we still have bottom:undefined.
Because bottom subsumes non-termination, the function isUndefined would have to solve the halting problem and thus cannot exist.
post = Post.find_by_id(1)
if post
return post.title
elsereturn nil
end
fmap (getPostTitle) (findPost 1)
--- or with infix
getPostTitle <$> (findPost 1)
Function to List?
ftolist
Because:
instanceFunctor [] where
fmap = map
What About Functions?
Normal:
regular
What About?:
applied
fmap (+3) (*2)
How?
instanceFunctor ((->) r) where
fmap f g = f . g
As a functor, it's function composition! As a monad:
instanceApplicative ((->) r) where-- pure :: a -> r -> a
pure = const
-- (<*>) :: (r -> a -> b) -> (r -> a) -> r -> b
(<*>) g f r = g r (f r)
instanceMonad ((->) r) where-- return :: a -> r -> a
return = const
-- (>>=) :: (r -> a) -> (a -> r -> b) -> r -> b
(>>=) x y z = y (x z) z
instanceFunctor [] where
fmap = map
instanceApplicative [] where
pure x = [x]
fs <*> xs = [f x | f <- fs, x <- xs]
xs *> ys = [y | _ <- xs, y <- ys]
instanceMonad [] where
xs >>= f = [y | x <- xs, y <- f x]
(>>) = (*>)
return x = [x]
fail _ = []
What is this?
-- So... what is this?
[(*2),(+3)] <*> [1, 2, 3]
answer
Applicatives CAN, Functors CAN'T
Apply function that takes 2 args to 2 wrapped values!
ghci>(+) <$> (Just5)
Just (+5)
ghci>Just (+5) <$>Just4ERRRRR
